/*#define BOOST_TEST_MODULE big_int test
#define BOOST_TEST_MAIN
#include <boost/test/included/unit_test.hpp>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

#include <iostream>
#include <algorithm>
#include <utility>

#include "big_int.h"

using namespace std;
using namespace boost;

const int TESTS_SIZE = 10;

namespace 
{
   mt19937 gen;

   int next_random()
   { 
      uniform_int<> dist(1, 2000000000);
      variate_generator<mt19937&, uniform_int<> > generate(gen, dist);
      return generate();
   }
}

BOOST_AUTO_TEST_CASE( construction_test ) 
{
   big_int a;
   big_int b(42);
   big_int c(a);
   cout << a << " " << b << " " << c << "\n";
}

BOOST_AUTO_TEST_CASE(comparation) 
{
   for (int i = 0; i < TESTS_SIZE; i++)
   {
      int a = next_random();
      int b = next_random();
      big_int ba = big_int(a);
      big_int bb = big_int(b);
      BOOST_CHECK_EQUAL(a < b, ba < bb);
      BOOST_CHECK_EQUAL(a <= b, ba <= bb);
      BOOST_CHECK_EQUAL(a > b, ba > bb);
      BOOST_CHECK_EQUAL(a >= b, ba >= bb);
      BOOST_CHECK_EQUAL(a == b, ba == bb);
      BOOST_CHECK_EQUAL(a != b, ba != bb);
   }
   {
      big_int a, b;
      BOOST_CHECK(a == b);
   }
   {
      big_int a("123456789123456789123456789000000000"), b("123456789123456789123456789000000000");
      BOOST_CHECK(a == b);
   }
}

BOOST_AUTO_TEST_CASE(plustest) 
{
   for (int i = 0; i < TESTS_SIZE; i++)
   {
      long long a = next_random();
      long long b = next_random();
      BOOST_CHECK_EQUAL(big_int(a) + big_int(b), big_int(a + b));
   }
   {
      big_int a, b;
      BOOST_CHECK(a + b == big_int(0));
   }
   {
      big_int a("999999999000000000111111111000000000");
      big_int b("1000000001111111111222222222000000000");
      big_int c("2000000000111111111333333333000000000");

      BOOST_CHECK_EQUAL(a + b, c);
   }
}

BOOST_AUTO_TEST_CASE(multest) 
{
   for (int i = 0; i < TESTS_SIZE; i++)
   {
      long long a = next_random();
      long long b = next_random();
      big_int aa = big_int(a) * big_int(b);
      BOOST_CHECK_EQUAL(aa, big_int(a * b));
   }
   {
      big_int a, b;
      BOOST_CHECK(a * b == big_int(0));
   }
   {
      big_int a("999999999000000000111111111000000000");
      big_int b("100000000000000000000000000000000000");
      big_int c("99999999900000000011111111100000000000000000000000000000000000000000000");

      BOOST_CHECK_EQUAL(a * b, c);
   }
}

BOOST_AUTO_TEST_CASE(minustest) 
{
   for (int i = 0; i < TESTS_SIZE; i++)
   {
      long long a = next_random();
      long long b = next_random();
      if (a < b)
         swap(a, b);
      big_int aa = big_int(a) - big_int(b);
      BOOST_CHECK_EQUAL(aa, big_int(a - b));
   }
   {
      big_int a, b;
      BOOST_CHECK(a - b == big_int(0));
   }
   {
      big_int a("100000000000000000000000000000000001");
                                         big_int b("2");
       big_int c("99999999999999999999999999999999999");

      BOOST_CHECK_EQUAL(a - b, c);
   }
}

BOOST_AUTO_TEST_CASE(dividetest) 
{
   for (int i = 0; i < TESTS_SIZE; i++)
   {
      long long a = next_random();
      long long b = next_random();
      if (b == 0)
         b = 2;
      pair<big_int, big_int> ans = (big_int(a)).divide_with_remainer(big_int(b));
      BOOST_CHECK_EQUAL(ans.first, big_int(a / b));
      BOOST_CHECK_EQUAL(ans.second, big_int(a % b));

   }
   {
      big_int a, b(1234);
      BOOST_CHECK(a.divide_with_remainer(b).first == big_int(0));
   }
   {
      big_int a("10000000000000000000000000000000000");
      big_int b("100");
      big_int c("100000000000000000000000000000000");
      big_int d(0);
      pair<big_int, big_int> ans = a.divide_with_remainer(b);
      BOOST_CHECK_EQUAL(ans.first, c);
      BOOST_CHECK_EQUAL(ans.second, d);
   }
}
*/